home *** CD-ROM | disk | FTP | other *** search
/ HamCall (October 1991) / HamCall (Whitehall Publishing)(1991).bin / prgming / ctutor / chap09.txt < prev    next >
Text File  |  1990-10-14  |  28KB  |  645 lines

  1.  
  2.                                                      Chapter 9
  3.  
  4.                                          STANDARD INPUT/OUTPUT
  5.  
  6.  
  7.  
  8. THE STDIO.H HEADER FILE
  9. ______________________________________________________________
  10.  
  11. Load the file SIMPLEIO.C for our first look     ==============
  12. at a file with standard I/O.  Standard I/O        SIMPLEIO.C
  13. refers to the most usual places where data is   ==============
  14. either read from, the keyboard, or written
  15. to, the video monitor.  Since they are used so much, they are
  16. used as the default I/O devices and do not need to be named
  17. in the Input/Output instructions.  This will make more sense
  18. when we actually start to use them so lets look at the file
  19. in front of you.
  20.  
  21. The first thing you will notice is the second line of the
  22. file, the #include "stdio.h" line.  This is very much like the
  23. #define we have already studied, except that instead of a
  24. simple substitution, an entire file is read in at this point.
  25. The system will find the file named "stdio.h" and read its
  26. entire contents in, replacing this statement.  Obviously then,
  27. the file named "stdio.h" must contain valid C source
  28. statements that can be compiled as part of a program.  This
  29. particular file is composed of several standard #defines to
  30. define some of the standard I/O operations.  The file is
  31. called a header file and you will find several different
  32. header files on the source disks that came with your C
  33. compiler.  Each of the header files has a specific purpose and
  34. any or all of them can be included in any program.
  35.  
  36. Your C compiler uses the double quote marks to indicate that
  37. the search for the "include" file will begin in the current
  38. directory, and if it not found there, the search will continue
  39. in the "include" directory as set up in the environment.  It
  40. also uses the "less than" and "greater than" signs to indicate
  41. that the file search should begin in the directory specified
  42. in the environment.  Most of the programs in this tutorial
  43. have the double quotes in the "include" statements.  The next
  44. program uses the "<" and ">" to illustrate the usage.  Note
  45. that this will result is a slightly faster (but probably
  46. unnoticeable) compilation because the system will not bother
  47. to search the current directory.
  48.  
  49.  
  50. INPUT/OUTPUT OPERATIONS IN C
  51. ______________________________________________________________
  52.  
  53. Actually the C programming language has no input or output
  54. operations defined as part of the language, they must be user
  55. defined.  Since everybody does not want to reinvent his own
  56. input and output operations, the compiler writers have done
  57. a lot of this for us and supplied us with several input
  58.  
  59.                                                            9-1
  60.  
  61.                              Chapter 9 - Standard Input/Output
  62.  
  63. functions and several output functions to aid in our program
  64. development.  The functions have become a standard, and you
  65. will find the same functions available in nearly every
  66. compiler.  In fact, the industry standard of the C language
  67. definition has become the book written by Kernigan and
  68. Ritchie, and they have included these functions in their
  69. definition.  You will often, when reading literature about C,
  70. find a reference to K & R.  This refers to the book, "The C
  71. Programming Language", written by Kernigan and Ritchie.  You
  72. would be advised to purchase a copy for reference.  As of this
  73. writing, a second edition of this book is available and is the
  74. preferred edition.
  75.  
  76. You should print out the file named "stdio.h" and spend some
  77. time studying it.  There will be a lot that you will not
  78. understand about it, but parts of it will look familiar.  The
  79. name "stdio.h" is sort of cryptic for "standard input/output
  80. header", because that is exactly what it is.  It defines the
  81. standard input and output functions in the form of #defines
  82. and macros.  Don't worry too much about the details of this
  83. now.  You can always return to this topic later for more study
  84. if it interests you, but you will really have no need to
  85. completely understand the "stdio.h" file.  You will have a
  86. tremendous need to use it however, so these comments on its
  87. use and purpose are necessary.
  88.  
  89.  
  90.  
  91. OTHER INCLUDE FILES
  92. ______________________________________________________________
  93.  
  94. When you begin writing larger programs and splitting them up
  95. into separately compiled portions, you will have occasion to
  96. use some statements common to each of the portions.  It would
  97. be to your advantage to make a separate file containing the
  98. statements and use the #include to insert it into each of the
  99. files.  If you want to change any of the common statements,
  100. you will only need to change one file and you will be assured
  101. of having all of the common statements agree.  This is getting
  102. a little ahead of ourselves but you now have an idea how the
  103. #include directive can be used.
  104.  
  105.  
  106. BACK TO THE FILE NAMED "SIMPLEIO.C"
  107. ______________________________________________________________
  108.  
  109. Lets continue our tour of the file in question.  The one
  110. variable "c" is defined and a message is printed out with the
  111. familiar "printf" function.  We then find ourselves in a
  112. continuous loop as long as "c" is not equal to capital X.  If
  113. there is any question in your mind about the loop control, you
  114. should review chapter 3 before continuing.  The two new
  115. functions within the loop are of paramount interest in this
  116. program since they are the new functions. These are functions
  117.  
  118.                                                            9-2
  119.  
  120.                              Chapter 9 - Standard Input/Output
  121.  
  122. to read a character from the keyboard and display it on the
  123. monitor one character at a time.
  124.  
  125. The function "getchar()" reads a single character from the
  126. standard input device, the keyboard being assumed because that
  127. is the standard input device, and assigns it to the variable
  128. "c".  The next function "putchar(c)", uses the standard output
  129. device, the video monitor, and outputs the character contained
  130. in the variable "c".  The character is output at the current
  131. cursor location and the cursor is advanced one space for the
  132. next character.  The system is therefore taking care of a lot
  133. of the overhead for us.  The loop continues reading and
  134. displaying characters until we type a capital X which
  135. terminates the loop.
  136.  
  137. Compile and run this program for a few surprises.  When you
  138. type on the keyboard, you will notice that what you type is
  139. displayed faithfully on the screen, and when you hit the
  140. return key, the entire line is repeated.  We only told it to
  141. output each character once but it seems to be saving the
  142. characters up and redisplaying them.  A short explanation is
  143. in order.
  144.  
  145.  
  146. DOS IS HELPING US OUT
  147. ______________________________________________________________
  148.  
  149. We need to understand a little bit about how DOS works to
  150. understand what is happening here.  When data is read from the
  151. keyboard, under DOS control, the characters are stored in a
  152. buffer until a carriage return is entered at which time the
  153. entire string of characters is given to the program.  When the
  154. characters are being typed, however, the characters are
  155. displayed one at a time on the monitor.  This is called echo,
  156. and happens in many of the applications you run.
  157.  
  158. With the above paragraph in mind, it should be clear that when
  159. you are typing a line of data into "SIMPLEIO", the characters
  160. are being echoed by DOS, and when you return the carriage, the
  161. characters are given to the program.  As each character is
  162. given to the program, it displays it on the screen resulting
  163. in a repeat of the line typed in.  To better illustrate this,
  164. type a line with a capital X somewhere in the middle of the
  165. line.  You can type as many characters as you like following
  166. the "X" and they will all display because the characters are
  167. being read in under DOS, echoed to the monitor, and placed in
  168. the DOS input buffer.  DOS doesn't think there is anything
  169. special about a capital X.  When the string is given to the
  170. program, however, the characters are accepted by the program
  171. one at a time and sent to the monitor one at a time, until a
  172. capital X is encountered.  After the capital X is displayed,
  173. the loop is terminated, and the program is terminated.  The
  174. characters on the input line following the capital X are not
  175. displayed because the capital X signalled program termination.
  176.  
  177.                                                            9-3
  178.  
  179.                              Chapter 9 - Standard Input/Output
  180.  
  181. Compile and run "SIMPLEIO.C".  After running the program
  182. several times and feeling confident that you understand the
  183. above explanation, we will go on to another program.
  184.  
  185. Don't get discouraged by the above seemingly wierd behavior
  186. of the I/O system.  It is strange, but there are other ways
  187. to get data into the computer.  You will actually find the
  188. above method useful for many applications, and you will
  189. probably find some of the following useful also.
  190.  
  191.  
  192. ANOTHER STRANGE I/O METHOD
  193. ______________________________________________________________
  194.  
  195. Load the file named SINGLEIO.C and display it   ==============
  196. on your monitor for another method of             SINGLEIO.C
  197. character I/O.  Once again, we start with the   ==============
  198. standard I/O header file using the "<" and
  199. ">" method of defining it.  Then we define a variable named
  200. "c", and finally we print a welcoming message.  Like the last
  201. program, we are in a loop that will continue to execute until
  202. we type a capital X, but the action is a little different
  203. here.
  204.  
  205. The "getch()" is a new function that is a "get character"
  206. function.  It differs from "getchar()" in that it does not get
  207. tied up in DOS.  It reads the character in without echo, and
  208. puts it directly into the program where it is operated on
  209. immediately.  This function therefore reads a character,
  210. immediately displays it on the screen, and continues the
  211. operation until a capital X is typed.
  212.  
  213. When you compile and run this program, you will find that
  214. there is no repeat of the lines when you hit a carriage
  215. return, and when you hit the capital X, the program terminates
  216. immediately.  No carriage return is needed to get it to accept
  217. the line with the X in it.  We do have another problem here,
  218. however, there is no linefeed with the carriage return.
  219.  
  220.  
  221. NOW WE NEED A LINE FEED
  222. ______________________________________________________________
  223.  
  224. It is not apparent to you in most application   ==============
  225. programs but when you hit the enter key, the      BETTERIN.C
  226. program supplies a linefeed to go with the      ==============
  227. carriage return.  You need to return to the
  228. left side of the monitor and you also need to drop down a
  229. line.  The linefeed is not automatic. We need to improve our
  230. program to do this also.  If you will load and display the
  231. program named BETTERIN.C, you will find a change to
  232. incorporate this feature.
  233.  
  234.                                                            9-4
  235.  
  236.                              Chapter 9 - Standard Input/Output
  237.  
  238. In BETTERIN.C, we have two additional statements at the
  239. beginning that will define the character codes for the
  240. linefeed (LF), and the carriage return (CR).  If you look at
  241. any ASCII table you will find that the codes 10 and 13 are
  242. exactly as defined here.  In the main program, after
  243. outputting the character, we compare it to CR, and if it is
  244. equal to CR, we also output a linefeed which is the LF.  We
  245. could have just left out the two #define statements and used
  246. "if (c == 13) putchar(10);" but it would not be very
  247. descriptive of what we are doing here.  The method used in the
  248. program represents better programming practice.
  249.  
  250. Compile and run BETTERIN.C to see if it does what we have said
  251. it should do.  It should display exactly what you type in,
  252. including a linefeed with each carriage return, and should
  253. stop immediately when you type a capital X.
  254.  
  255.  
  256. WHICH METHOD IS BEST?
  257. ______________________________________________________________
  258.  
  259. We have examined two methods of reading characters into a C
  260. program, and are faced with a choice of which one we should
  261. use.  It really depends on the application because each method
  262. has advantages and disadvantages.
  263.  
  264. When using the first method, DOS is actually doing all of the
  265. work for us by storing the characters in an input buffer and
  266. signalling us when a full line has been entered.  We could
  267. write a program that, for example, did a lot of calculations,
  268. then went to get some input.  While we were doing the
  269. calculations, DOS would be accumulating a line of characters
  270. for us, and they would be there when we were ready for them.
  271. However, we could not read in single keystrokes because DOS
  272. would not report a buffer of characters to us until it
  273. recognized a carriage return.
  274.  
  275. The second method, used in BETTERIN.C, allows us to get a
  276. single character, and act on it immediately.  We do not have
  277. to wait until DOS decides we can have a line of characters.
  278. We cannot do anything else while we are waiting for a
  279. character because we are waiting for the input keystroke and
  280. tying up the entire machine.  This method is useful for highly
  281. interactive types of program interfaces.  It is up to you as
  282. the programmer to decide which is best for your needs.
  283.  
  284. I should mention at this point that there is also an "ungetch"
  285. function that works with the "getch" function.  If you "getch"
  286. a character and find that you have gone one too far, you can
  287. "ungetch" it back to the input device.  This simplifies some
  288. programs because you don't know that you don't want the
  289. character until you get it.  You can only "ungetch" one
  290. character back to the input device, but that is sufficient to
  291. accomplish the task this function was designed for.  It is
  292.  
  293.                                                            9-5
  294.  
  295.                              Chapter 9 - Standard Input/Output
  296.  
  297. difficult to demonstrate this function in a simple program so
  298. its use will be up to you to study when you need it.
  299.  
  300. The discussion so far in this chapter, should be a good
  301. indication that, while the C programming language is very
  302. flexible, it does put a lot of responsibility on you as the
  303. programmer to keep many details in mind.
  304.  
  305.  
  306. NOW TO READ IN SOME INTEGERS
  307. ______________________________________________________________
  308.  
  309. Load and display the file named INTIN.C for      =============
  310. an example of reading in some formatted data.       INTIN.C
  311. The structure of this program is very similar    =============
  312. to the last three except that we define an
  313. "int" type variable and loop until the variable somehow
  314. acquires the value of 100.
  315.  
  316. Instead of reading in a character at a time, as we have in the
  317. last three files, we read in an entire integer value with one
  318. call using the function named "scanf".  This function is very
  319. similar to the "printf" that you have been using for quite
  320. some time by now except that it is used for input instead of
  321. output.  Examine the line with the "scanf" and you will notice
  322. that it does not ask for the variable "valin" directly, but
  323. gives the address of the variable since it expects to have a
  324. value returned from the function.  Recall that a function must
  325. have the address of a variable in order to return a value to
  326. that variable in the calling program.  Failing to supply a
  327. pointer in the "scanf" function is the most common problem
  328. encountered in using this function.
  329.  
  330. The function "scanf" scans the input line until it finds the
  331. first data field.  It ignores leading blanks and in this case,
  332. it reads integer characters until it finds a blank or an
  333. invalid decimal character, at which time it stops reading and
  334. returns the value.
  335.  
  336. Remembering our discussion above about the way the DOS input
  337. buffer works, it should be clear that nothing is actually
  338. acted on until a complete line is entered and it is terminated
  339. by a carriage return.  At this time, the buffer is input, and
  340. our program will search across the line reading all integer
  341. values it can find until the line is completely scanned.  This
  342. is because we are in a loop and we tell it to find a value,
  343. print it, find another, print it, etc.  If you enter several
  344. values on one line, it will read each one in succession and
  345. display the values.  Entering the value of 100 will cause the
  346. program to terminate, and entering the value 100 with other
  347. values following, will cause termination before the following
  348. values are considered.
  349.  
  350.  
  351.                                                            9-6
  352.  
  353.                              Chapter 9 - Standard Input/Output
  354.  
  355. IT MAKES WRONG ANSWERS SOMETIMES
  356. ______________________________________________________________
  357.  
  358. If you enter a number up to and including 32767, it will
  359. display correctly, but if you enter a larger number, it will
  360. appear to make an error.  For example, if you enter the value
  361. 32768, it will display the value of -32768, entering the value
  362. 65536 will display as a zero.  These are not errors but are
  363. caused by the way an integer is defined.  The most significant
  364. bit of the 16 bit pattern available for the integer variable
  365. is the sign bit, so there are only 15 bits left for the value.
  366. The variable can therefore only have the values from -32768
  367. to 32767, any other values are outside the range of integer
  368. variables.  This is up to you to take care of in your
  369. programs.  It is another example of the increased
  370. responsibility you must assume using C rather than a higher
  371. level language such as Pascal, Modula-2, etc.
  372.  
  373. The above paragraph is true for most MS-DOS C compilers.
  374. There is a very small possibility that your compiler uses an
  375. integer value stored in a field size other than 16 bits.  If
  376. that is the case, the same principles will be true but with
  377. different limits than those given above.
  378.  
  379. Compile and run this program, entering several numbers on a
  380. line to see the results, and with varying numbers of blanks
  381. between the numbers.  Try entering numbers that are too big
  382. to see what happens, and finally enter some invalid characters
  383. to see what the system does with nondecimal characters.
  384.  
  385.  
  386. CHARACTER STRING INPUT
  387. ______________________________________________________________
  388.  
  389. Load and display the file named STRINGIN.C      ==============
  390. for an example of reading a string variable.      STRINGIN.C
  391. This program is identical to the last one       ==============
  392. except that instead of an integer variable,
  393. we have defined a string variable with an upper limit of 24
  394. characters (remember that a string variable must have a null
  395. character at the end).  The variable in the "scanf" does not
  396. need an & because "big" is an array variable and by definition
  397. it is already a pointer.  This program should require no
  398. additional explanation.  Compile and run it to see if it works
  399. the way you expect.
  400.  
  401. You probably got a surprise when you ran it because it
  402. separated your sentence into separate words.  When used in the
  403. string mode of input, "scanf" reads characters into the string
  404. until it comes to either the end of a line or a blank
  405. character.  Therefore, it reads a word, finds the blank
  406. following it, and displays the result.  Since we are in a
  407. loop, this program continues to read words until it exhausts
  408. the DOS input buffer.  We have written this program to stop
  409.  
  410.                                                            9-7
  411.  
  412.                              Chapter 9 - Standard Input/Output
  413.  
  414. whenever it finds a capital X in column 1, but since the
  415. sentence is split up into individual words, it will stop
  416. anytime a word begins with capital X.  Try entering a 5 word
  417. sentence with a capital X as the first character in the third
  418. word.  You should get the first three words displayed, and the
  419. last two simply ignored when the program stops.
  420.  
  421. Try entering more than 24 characters to see what the program
  422. does.  In an actual program, it is your responsibility to
  423. count characters and stop when the input buffer is full.  You
  424. may be getting the feeling that a lot of responsibility is
  425. placed on you when writing in C.  It is, but you also get a
  426. lot of flexibility in the bargain too.
  427.  
  428.  
  429. INPUT/OUTPUT PROGRAMMING IN C
  430. ______________________________________________________________
  431.  
  432. C was not designed to be used as a language for lots of input
  433. and output, but as a systems language where a lot of internal
  434. operations are required.  You would do well to use another
  435. language for I/O intensive programming, but C could be used
  436. if you desire.  The keyboard input is very flexible, allowing
  437. you to get at the data in a very low level way, but very
  438. little help is given you.  It is therefore up to you to take
  439. care of all of the bookkeeping chores associated with your
  440. required I/O operations.  This may seem like a real pain in
  441. the neck, but in any given program, you only need to define
  442. your input routines once and then use them as needed.  Don't
  443. let this worry you.  As you gain experience with C, you will
  444. easily handle your I/O requirements.
  445.  
  446. One final point must be made about these I/O functions.  It
  447. is perfectly permissible to intermix "scanf" and "getchar"
  448. functions during read operations.  In the same manner, it is
  449. also fine to intermix the output functions, "printf" and
  450. "putchar".
  451.  
  452.  
  453. IN MEMORY I/O
  454. ______________________________________________________________
  455.  
  456. The next operation may seem a little strange     =============
  457. at first, but you will probably see lots of         INMEM.C
  458. uses for it as you gain experience.  Load the    =============
  459. file named INMEM.C and display it for another
  460. type of I/O, one that never accesses the outside world, but
  461. stays in the computer.
  462.  
  463. In INMEM.C, we define a few variables, then assign some values
  464. to the ones named "numbers" for illustrative purposes and then
  465. use a "sprintf" function.  The function acts just like a
  466. normal "printf" function except that instead of printing the
  467. line of output to a device, it prints the line of formatted
  468.  
  469.                                                            9-8
  470.  
  471.                              Chapter 9 - Standard Input/Output
  472.  
  473. output to a character string in memory.  In this case the
  474. string goes to the string variable "line", because that is the
  475. string name we inserted as the first argument in the "sprintf"
  476. function.  The spaces after the 2nd %d were put there to
  477. illustrate that the next function will search properly across
  478. the line.  We print the resulting string and find that the
  479. output is identical to what it would have been by using a
  480. "printf" instead of the "sprintf" in the first place.  You
  481. will see that when you compile and run the program shortly.
  482.  
  483. Since the generated string is still in memory, we can now read
  484. it with the function "sscanf".  We tell the function in its
  485. first argument that "line" is the string to use for its input,
  486. and the remaining parts of the line are exactly what we would
  487. use if we were going to use the "scanf" function and read data
  488. from outside the computer.  Note that it is essential that we
  489. use pointers to the data because we want to return data from
  490. a function.  Just to illustrate that there are many ways to
  491. declare a pointer several methods are used, but all are
  492. pointers.  The first two simply declare the address of the
  493. elements of the array, while the last three use the fact that
  494. "result", without the accompanying subscript, is a pointer.
  495. Just to keep it interesting, the values are read back in
  496. reverse order.  Finally the values are displayed on the
  497. monitor.
  498.  
  499.  
  500.  
  501. IS THAT REALLY USEFUL?
  502. ______________________________________________________________
  503.  
  504. It seems sort of silly to read input data from within the
  505. computer but it does have a real purpose.  It is possible to
  506. read data from an input device using any of the standard
  507. functions and then do a format conversion in memory.  You
  508. could read in a line of data, look at a few significant
  509. characters, then use these formatted input routines to reduce
  510. the line of data to internal representation.  That would sure
  511. beat writing your own data formatting routines.
  512.  
  513.  
  514. STANDARD ERROR OUTPUT
  515. ______________________________________________________________
  516.  
  517. Sometimes it is desirable to redirect the        =============
  518. output from the standard output device to a        SPECIAL.C
  519. file.  However, you may still want the error     =============
  520. messages to go to the standard output device,
  521. in our case the monitor.  This next function allows you to do
  522. that.  Load and display SPECIAL.C for an example of this new
  523. function.
  524.  
  525. The program consists of a loop with two messages output, one
  526. to the standard output device and the other to the standard
  527.  
  528.                                                            9-9
  529.  
  530.                              Chapter 9 - Standard Input/Output
  531.  
  532. error device.  The message to the standard error device is
  533. output with the function "fprintf" and includes the device
  534. name "stderr" as the first argument.  Other than those two
  535. small changes, it is the same as our standard "printf"
  536. function.  (You will see more of the "fprintf" function in the
  537. next chapter, but its operation fit in better as a part of
  538. this chapter.)  Ignore the line with the "exit" for the
  539. moment, we will return to it.
  540.  
  541. Compile and run this program, and you will find 12 lines of
  542. output on the monitor.  To see the difference, run the program
  543. again with redirected output to a file named "STUFF" by
  544. entering the following line at the Dos prompt;
  545.  
  546.      A> special >stuff
  547.  
  548. More information about I/O redirection can be found in your
  549. DOS manual.  This time you will only get the 6 lines output
  550. to the standard error device, and if you look in your
  551. directory, you will find the file named "STUFF" containing the
  552. other 6 lines, those to the standard output device.  You can
  553. use I/O redirection with any of the programs we have run so
  554. far, and as you may guess, you can also read from a file using
  555. I/O redirection but we will study a better way to read from
  556. a file in the next chapter.
  557.  
  558.  
  559.  
  560. WHAT ABOUT THE exit(4) STATEMENT?
  561. ______________________________________________________________
  562.  
  563. Now to keep our promise about the exit(4) statement. Redisplay
  564. the file named SPECIAL.C on your monitor.  The last statement
  565. simply exits the program and returns the value of 4 to DOS.
  566. Any number from 0 to 9 can be used in the parentheses for DOS
  567. communication.  If you are operating in a BATCH file, this
  568. number can be tested with the "ERRORLEVEL" command.
  569.  
  570. Most compilers that operate in several passes return a 1 with
  571. this mechanism to indicate that a fatal error has been
  572. detected and it would be a waste of time to go on to another
  573. pass resulting in even more errors.
  574.  
  575. It is therefore wise to use a batch file for compiling
  576. programs and testing the returned value for errors.  A check
  577. of the documentation for my COMPAQ, resulted in a minimal and
  578. confusing documentation of the "ERRORLEVEL" command, so a
  579. brief description of it is given in this file in case your
  580. documentation does not include enough information to allow you
  581. to use it.
  582.  
  583.  
  584.  
  585.  
  586.                                                           9-10
  587.  
  588.                              Chapter 9 - Standard Input/Output
  589.  
  590. PROGRAMMING EXERCISE
  591. ______________________________________________________________
  592.  
  593. 1.   Write a program to  read in a character using a loop, and
  594.      display the character in its normal "char" form.  Also
  595.      display it as a decimal number. Check for a dollar sign
  596.      to use as the stop character. Use the "getch" form of
  597.      input so it will print immediately. Hit some of the
  598.      special keys, such as function keys, when you run the
  599.      program for some surprises. You will get two inputs from
  600.      the special keys, the first being a zero which is the
  601.      indication to the system that a special key was hit.
  602.  
  603.  
  604.  
  605.  
  606.  
  607.  
  608.  
  609.  
  610.  
  611.  
  612.  
  613.  
  614.  
  615.  
  616.  
  617.  
  618.  
  619.  
  620.  
  621.  
  622.  
  623.  
  624.  
  625.  
  626.  
  627.  
  628.  
  629.  
  630.  
  631.  
  632.  
  633.  
  634.  
  635.  
  636.  
  637.  
  638.  
  639.  
  640.  
  641.  
  642.  
  643.                                                           9-11
  644.  
  645.